home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / CIncludes / Drag.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-11  |  16.2 KB  |  417 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        Drag.h
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. */
  16.  
  17. #ifndef __DRAG__
  18. #define __DRAG__
  19.  
  20.  
  21. #ifndef __APPLEEVENTS__
  22. #include <AppleEvents.h>
  23. #endif
  24. /*    #include <Errors.h>                                            */
  25. /*        #include <ConditionalMacros.h>                            */
  26. /*    #include <Types.h>                                            */
  27. /*    #include <Memory.h>                                            */
  28. /*        #include <MixedMode.h>                                    */
  29. /*    #include <OSUtils.h>                                        */
  30. /*    #include <Events.h>                                            */
  31. /*        #include <Quickdraw.h>                                    */
  32. /*            #include <QuickdrawText.h>                            */
  33. /*    #include <EPPC.h>                                            */
  34. /*        #include <PPCToolbox.h>                                    */
  35. /*            #include <AppleTalk.h>                                */
  36. /*        #include <Processes.h>                                    */
  37. /*            #include <Files.h>                                    */
  38. /*    #include <Notification.h>                                    */
  39.  
  40. #ifndef __TEXTEDIT__
  41. #include <TextEdit.h>
  42. #endif
  43.  
  44. #ifdef __cplusplus
  45. extern "C" {
  46. #endif
  47.  
  48. #if GENERATINGPOWERPC
  49. #pragma options align=mac68k
  50. #endif
  51.  
  52. #ifdef __CFM68K__
  53. #pragma lib_export on
  54. #endif
  55.  
  56.  
  57. enum {
  58. /* Flavor Flags */
  59.     flavorSenderOnly            = 0x00000001L,                    /* flavor is available to sender only */
  60.     flavorSenderTranslated        = 0x00000002L,                    /* flavor is translated by sender */
  61.     flavorNotSaved                = 0x00000004L,                    /* flavor should not be saved */
  62.     flavorSystemTranslated        = 0x00000100L                    /* flavor is translated by system */
  63. };
  64.  
  65. typedef unsigned long FlavorFlags;
  66.  
  67.  
  68. enum {
  69. /* Drag Attributes */
  70.     dragHasLeftSenderWindow        = 0x00000001L,                    /* drag has left the source window since TrackDrag */
  71.     dragInsideSenderApplication    = 0x00000002L,                    /* drag is occurring within the sender application */
  72.     dragInsideSenderWindow        = 0x00000004L                    /* drag is occurring within the sender window */
  73. };
  74.  
  75. typedef unsigned long DragAttributes;
  76.  
  77.  
  78. enum {
  79. /* Special Flavor Types */
  80.     flavorTypeHFS                = 'hfs ',                        /* flavor type for HFS data */
  81.     flavorTypePromiseHFS        = 'phfs',                        /* flavor type for promised HFS data */
  82.     flavorTypeDirectory            = 'diry'
  83. };
  84.  
  85. enum {
  86. /* Drag Tracking Handler Messages */
  87.     dragTrackingEnterHandler    = 1,                            /* drag has entered handler */
  88.     dragTrackingEnterWindow        = 2,                            /* drag has entered window */
  89.     dragTrackingInWindow        = 3,                            /* drag is moving within window */
  90.     dragTrackingLeaveWindow        = 4,                            /* drag has exited window */
  91.     dragTrackingLeaveHandler    = 5                                /* drag has exited handler */
  92. };
  93.  
  94. typedef short DragTrackingMessage;
  95.  
  96.  
  97. enum {
  98. /* Drag Drawing Procedure Messages */
  99.     dragRegionBegin                = 1,                            /* initialize drawing */
  100.     dragRegionDraw                = 2,                            /* draw drag feedback */
  101.     dragRegionHide                = 3,                            /* hide drag feedback */
  102.     dragRegionIdle                = 4,                            /* drag feedback idle time */
  103.     dragRegionEnd                = 5                                /* end of drawing */
  104. };
  105.  
  106. typedef short DragRegionMessage;
  107.  
  108.  
  109. enum {
  110. /* Zoom Acceleration */
  111.     zoomNoAcceleration            = 0,                            /* use linear interpolation */
  112.     zoomAccelerate                = 1,                            /* ramp up step size */
  113.     zoomDecelerate                = 2                                /* ramp down step size */
  114. };
  115.  
  116. typedef short ZoomAcceleration;
  117.  
  118. /* Drag Manager Data Types */
  119. typedef unsigned long DragReference;
  120.  
  121. typedef unsigned long ItemReference;
  122.  
  123. typedef ResType FlavorType;
  124.  
  125. /* HFS Flavors */
  126. struct HFSFlavor {
  127.     OSType                            fileType;                    /* file type */
  128.     OSType                            fileCreator;                /* file creator */
  129.     unsigned short                    fdFlags;                    /* Finder flags */
  130.     FSSpec                            fileSpec;                    /* file system specification */
  131. };
  132. typedef struct HFSFlavor HFSFlavor;
  133.  
  134. struct PromiseHFSFlavor {
  135.     OSType                            fileType;                    /* file type */
  136.     OSType                            fileCreator;                /* file creator */
  137.     unsigned short                    fdFlags;                    /* Finder flags */
  138.     FlavorType                        promisedFlavor;                /* promised flavor containing an FSSpec */
  139. };
  140. typedef struct PromiseHFSFlavor PromiseHFSFlavor;
  141.  
  142. /* Application-Defined Drag Handler Routines */
  143. typedef pascal OSErr (*DragTrackingHandlerProcPtr)(DragTrackingMessage message, WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  144.  
  145. #if GENERATINGCFM
  146. typedef UniversalProcPtr DragTrackingHandlerUPP;
  147. #else
  148. typedef DragTrackingHandlerProcPtr DragTrackingHandlerUPP;
  149. #endif
  150.  
  151. enum {
  152.     uppDragTrackingHandlerProcInfo = kPascalStackBased
  153.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  154.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragTrackingMessage)))
  155.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(WindowPtr)))
  156.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  157.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  158. };
  159.  
  160. #if GENERATINGCFM
  161. #define NewDragTrackingHandlerProc(userRoutine)        \
  162.         (DragTrackingHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, GetCurrentArchitecture())
  163. #else
  164. #define NewDragTrackingHandlerProc(userRoutine)        \
  165.         ((DragTrackingHandlerUPP) (userRoutine))
  166. #endif
  167.  
  168. #if GENERATINGCFM
  169. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  170.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, (message), (theWindow), (handlerRefCon), (theDragRef))
  171. #else
  172. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  173.         (*(userRoutine))((message), (theWindow), (handlerRefCon), (theDragRef))
  174. #endif
  175.  
  176. typedef DragTrackingHandlerUPP DragTrackingHandler;
  177.  
  178. typedef pascal OSErr (*DragReceiveHandlerProcPtr)(WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  179.  
  180. #if GENERATINGCFM
  181. typedef UniversalProcPtr DragReceiveHandlerUPP;
  182. #else
  183. typedef DragReceiveHandlerProcPtr DragReceiveHandlerUPP;
  184. #endif
  185.  
  186. enum {
  187.     uppDragReceiveHandlerProcInfo = kPascalStackBased
  188.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  189.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  190.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  191.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DragReference)))
  192. };
  193.  
  194. #if GENERATINGCFM
  195. #define NewDragReceiveHandlerProc(userRoutine)        \
  196.         (DragReceiveHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, GetCurrentArchitecture())
  197. #else
  198. #define NewDragReceiveHandlerProc(userRoutine)        \
  199.         ((DragReceiveHandlerUPP) (userRoutine))
  200. #endif
  201.  
  202. #if GENERATINGCFM
  203. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  204.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, (theWindow), (handlerRefCon), (theDragRef))
  205. #else
  206. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  207.         (*(userRoutine))((theWindow), (handlerRefCon), (theDragRef))
  208. #endif
  209.  
  210. typedef DragReceiveHandlerUPP DragReceiveHandler;
  211.  
  212. /* Application-Defined Routines */
  213. typedef pascal OSErr (*DragSendDataProcPtr)(FlavorType theType, void *dragSendRefCon, ItemReference theItemRef, DragReference theDragRef);
  214.  
  215. #if GENERATINGCFM
  216. typedef UniversalProcPtr DragSendDataUPP;
  217. #else
  218. typedef DragSendDataProcPtr DragSendDataUPP;
  219. #endif
  220.  
  221. enum {
  222.     uppDragSendDataProcInfo = kPascalStackBased
  223.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  224.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FlavorType)))
  225.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  226.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ItemReference)))
  227.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  228. };
  229.  
  230. #if GENERATINGCFM
  231. #define NewDragSendDataProc(userRoutine)        \
  232.         (DragSendDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragSendDataProcInfo, GetCurrentArchitecture())
  233. #else
  234. #define NewDragSendDataProc(userRoutine)        \
  235.         ((DragSendDataUPP) (userRoutine))
  236. #endif
  237.  
  238. #if GENERATINGCFM
  239. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  240.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragSendDataProcInfo, (theType), (dragSendRefCon), (theItemRef), (theDragRef))
  241. #else
  242. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  243.         (*(userRoutine))((theType), (dragSendRefCon), (theItemRef), (theDragRef))
  244. #endif
  245.  
  246. typedef DragSendDataUPP DragSendDataProc;
  247.  
  248. typedef pascal OSErr (*DragInputProcPtr)(Point *mouse, short *modifiers, void *dragInputRefCon, DragReference theDragRef);
  249.  
  250. #if GENERATINGCFM
  251. typedef UniversalProcPtr DragInputUPP;
  252. #else
  253. typedef DragInputProcPtr DragInputUPP;
  254. #endif
  255.  
  256. enum {
  257.     uppDragInputProcInfo = kPascalStackBased
  258.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  259.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Point*)))
  260.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short*)))
  261.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  262.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  263. };
  264.  
  265. #if GENERATINGCFM
  266. #define NewDragInputProc(userRoutine)        \
  267.         (DragInputUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture())
  268. #else
  269. #define NewDragInputProc(userRoutine)        \
  270.         ((DragInputUPP) (userRoutine))
  271. #endif
  272.  
  273. #if GENERATINGCFM
  274. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  275.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragInputProcInfo, (mouse), (modifiers), (dragInputRefCon), (theDragRef))
  276. #else
  277. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  278.         (*(userRoutine))((mouse), (modifiers), (dragInputRefCon), (theDragRef))
  279. #endif
  280.  
  281. typedef DragInputUPP DragInputProc;
  282.  
  283. typedef pascal OSErr (*DragDrawingProcPtr)(DragRegionMessage message, RgnHandle showRegion, Point showOrigin, RgnHandle hideRegion, Point hideOrigin, void *dragDrawingRefCon, DragReference theDragRef);
  284.  
  285. #if GENERATINGCFM
  286. typedef UniversalProcPtr DragDrawingUPP;
  287. #else
  288. typedef DragDrawingProcPtr DragDrawingUPP;
  289. #endif
  290.  
  291. enum {
  292.     uppDragDrawingProcInfo = kPascalStackBased
  293.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  294.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragRegionMessage)))
  295.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RgnHandle)))
  296.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Point)))
  297.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RgnHandle)))
  298.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Point)))
  299.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(void*)))
  300.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DragReference)))
  301. };
  302.  
  303. #if GENERATINGCFM
  304. #define NewDragDrawingProc(userRoutine)        \
  305.         (DragDrawingUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragDrawingProcInfo, GetCurrentArchitecture())
  306. #else
  307. #define NewDragDrawingProc(userRoutine)        \
  308.         ((DragDrawingUPP) (userRoutine))
  309. #endif
  310.  
  311. #if GENERATINGCFM
  312. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  313.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragDrawingProcInfo, (message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  314. #else
  315. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  316.         (*(userRoutine))((message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  317. #endif
  318.  
  319. typedef DragDrawingUPP DragDrawingProc;
  320.  
  321. /* Drag Manager Routines */
  322. /* Installing and Removing Drag Handlers */
  323. extern pascal OSErr InstallTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow, void *handlerRefCon)
  324.  TWOWORDINLINE(0x7001, 0xABED);
  325. extern pascal OSErr InstallReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow, void *handlerRefCon)
  326.  TWOWORDINLINE(0x7002, 0xABED);
  327. extern pascal OSErr RemoveTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow)
  328.  TWOWORDINLINE(0x7003, 0xABED);
  329. extern pascal OSErr RemoveReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow)
  330.  TWOWORDINLINE(0x7004, 0xABED);
  331. /* Creating and Disposing Drag References */
  332. extern pascal OSErr NewDrag(DragReference *theDragRef)
  333.  TWOWORDINLINE(0x7005, 0xABED);
  334. extern pascal OSErr DisposeDrag(DragReference theDragRef)
  335.  TWOWORDINLINE(0x7006, 0xABED);
  336. /* Adding Drag Item Flavors */
  337. extern pascal OSErr AddDragItemFlavor(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size dataSize, FlavorFlags theFlags)
  338.  TWOWORDINLINE(0x7007, 0xABED);
  339. extern pascal OSErr SetDragItemFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, const void *dataPtr, Size dataSize, unsigned long dataOffset)
  340.  TWOWORDINLINE(0x7009, 0xABED);
  341. /* Providing Drag Callback Procedures */
  342. extern pascal OSErr SetDragSendProc(DragReference theDragRef, DragSendDataProc sendProc, void *dragSendRefCon)
  343.  TWOWORDINLINE(0x700A, 0xABED);
  344. extern pascal OSErr SetDragInputProc(DragReference theDragRef, DragInputProc inputProc, void *dragInputRefCon)
  345.  TWOWORDINLINE(0x700B, 0xABED);
  346. extern pascal OSErr SetDragDrawingProc(DragReference theDragRef, DragDrawingProc drawingProc, void *dragDrawingRefCon)
  347.  TWOWORDINLINE(0x700C, 0xABED);
  348. /* Performing a Drag */
  349. extern pascal OSErr TrackDrag(DragReference theDragRef, const EventRecord *theEvent, RgnHandle theRegion)
  350.  TWOWORDINLINE(0x700D, 0xABED);
  351. /* Getting Drag Item Information */
  352. extern pascal OSErr CountDragItems(DragReference theDragRef, unsigned short *numItems)
  353.  TWOWORDINLINE(0x700E, 0xABED);
  354. extern pascal OSErr GetDragItemReferenceNumber(DragReference theDragRef, unsigned short index, ItemReference *theItemRef)
  355.  TWOWORDINLINE(0x700F, 0xABED);
  356. extern pascal OSErr CountDragItemFlavors(DragReference theDragRef, ItemReference theItemRef, unsigned short *numFlavors)
  357.  TWOWORDINLINE(0x7010, 0xABED);
  358. extern pascal OSErr GetFlavorType(DragReference theDragRef, ItemReference theItemRef, unsigned short index, FlavorType *theType)
  359.  TWOWORDINLINE(0x7011, 0xABED);
  360. extern pascal OSErr GetFlavorFlags(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, FlavorFlags *theFlags)
  361.  TWOWORDINLINE(0x7012, 0xABED);
  362. extern pascal OSErr GetFlavorDataSize(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, Size *dataSize)
  363.  TWOWORDINLINE(0x7013, 0xABED);
  364. extern pascal OSErr GetFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size *dataSize, unsigned long dataOffset)
  365.  TWOWORDINLINE(0x7014, 0xABED);
  366. extern pascal OSErr GetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, Rect *itemBounds)
  367.  TWOWORDINLINE(0x7015, 0xABED);
  368. extern pascal OSErr SetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, const Rect *itemBounds)
  369.  TWOWORDINLINE(0x7016, 0xABED);
  370. extern pascal OSErr GetDropLocation(DragReference theDragRef, AEDesc *dropLocation)
  371.  TWOWORDINLINE(0x7017, 0xABED);
  372. extern pascal OSErr SetDropLocation(DragReference theDragRef, const AEDesc *dropLocation)
  373.  TWOWORDINLINE(0x7018, 0xABED);
  374. /* Getting Information About a Drag */
  375. extern pascal OSErr GetDragAttributes(DragReference theDragRef, DragAttributes *flags)
  376.  TWOWORDINLINE(0x7019, 0xABED);
  377. extern pascal OSErr GetDragMouse(DragReference theDragRef, Point *mouse, Point *pinnedMouse)
  378.  TWOWORDINLINE(0x701A, 0xABED);
  379. extern pascal OSErr SetDragMouse(DragReference theDragRef, Point pinnedMouse)
  380.  TWOWORDINLINE(0x701B, 0xABED);
  381. extern pascal OSErr GetDragOrigin(DragReference theDragRef, Point *initialMouse)
  382.  TWOWORDINLINE(0x701C, 0xABED);
  383. extern pascal OSErr GetDragModifiers(DragReference theDragRef, short *modifiers, short *mouseDownModifiers, short *mouseUpModifiers)
  384.  TWOWORDINLINE(0x701D, 0xABED);
  385. /* Drag Highlighting */
  386. extern pascal OSErr ShowDragHilite(DragReference theDragRef, RgnHandle hiliteFrame, Boolean inside)
  387.  TWOWORDINLINE(0x701E, 0xABED);
  388. extern pascal OSErr HideDragHilite(DragReference theDragRef)
  389.  TWOWORDINLINE(0x701F, 0xABED);
  390. extern pascal OSErr DragPreScroll(DragReference theDragRef, short dH, short dV)
  391.  TWOWORDINLINE(0x7020, 0xABED);
  392. extern pascal OSErr DragPostScroll(DragReference theDragRef)
  393.  TWOWORDINLINE(0x7021, 0xABED);
  394. extern pascal OSErr UpdateDragHilite(DragReference theDragRef, RgnHandle updateRgn)
  395.  TWOWORDINLINE(0x7022, 0xABED);
  396. /* Drag Manager Utilities */
  397. extern pascal Boolean WaitMouseMoved(Point initialMouse)
  398.  TWOWORDINLINE(0x7023, 0xABED);
  399. extern pascal OSErr ZoomRects(const Rect *fromRect, const Rect *toRect, short zoomSteps, ZoomAcceleration acceleration)
  400.  TWOWORDINLINE(0x7024, 0xABED);
  401. extern pascal OSErr ZoomRegion(RgnHandle region, Point zoomDistance, short zoomSteps, ZoomAcceleration acceleration)
  402.  TWOWORDINLINE(0x7025, 0xABED);
  403.  
  404. #ifdef __CFM68K__
  405. #pragma lib_export off
  406. #endif
  407.  
  408. #if GENERATINGPOWERPC
  409. #pragma options align=reset
  410. #endif
  411.  
  412. #ifdef __cplusplus
  413. }
  414. #endif
  415.  
  416. #endif /* __DRAG__ */
  417.